home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / ue312src.zip / OS2NPM.C < prev    next >
C/C++ Source or Header  |  1993-04-20  |  21KB  |  813 lines
  1. /*
  2.  * OS2NONPM.C
  3.  *
  4.  * The routines in this file provide video and keyboard support using the
  5.  * OS/2 Vio and Kbd functions (not the presentation manager).
  6.  *
  7.  * The os2putc, os2eeol and os2eeop routines modify the logical video
  8.  * buffer.  Os2flush calls VioShowBuf to update the physical video buffer.
  9.  * An earlier version used VioWrtTTy with ANSI processing (easy to do, but
  10.  * sloooow).  A later version using VioWrtNCell was better, but not as
  11.  * good as manipulating the logical buffer.
  12.  */
  13.  
  14. #define INCL_BASE
  15. #include    <os2.h>
  16.  
  17. #define    termdef    1            /* don't define "term" external */
  18.  
  19. #include    <stdio.h>
  20.  
  21. #undef    PASCAL
  22. #undef    NEAR
  23. #undef    HIBYTE
  24.  
  25. #include    "estruct.h"
  26. #include    "eproto.h"
  27. #include    "edef.h"
  28. #include    "elang.h"
  29.  
  30. #if     OS2NPM
  31. /*
  32.  * Os2def.h defines COLOR, but no MSC stuff needs it.
  33.  * We need COLOR as defined in estruct.h, so edit it out of os2def.h.
  34.  */
  35. #include    <conio.h>
  36.  
  37. #define    NROW    102        /* Screen size.                 */
  38. #define    NCOL    80        /* Edit if you want to.         */
  39. #define    MARGIN    8        /* size of minimim margin and    */
  40. #define    SCRSIZ    64        /* scroll size for extended lines */
  41. #define    NPAUSE    100        /* # times thru update to pause */
  42.  
  43. #define CDCGA    0        /* color graphics adapter    */
  44. #define CDMONO    1        /* monochrome display adapter    */
  45. #define CDEGA    2        /* EGA                */
  46. #define CDVGA    3        /* VGA                */
  47.  
  48. #define NDRIVE    4        /* number of video modes    */
  49.  
  50. int dtype = -1;                /* current video mode    */
  51. char drvname[][8] = {            /* names of video modes    */
  52.     "CGA", "MONO", "EGA", "VGA"
  53. };
  54.  
  55. /* Forward references.          */
  56.  
  57. PASCAL NEAR os2move();
  58. PASCAL NEAR os2eeol();
  59. PASCAL NEAR os2eeop();
  60. PASCAL NEAR os2beep();
  61. PASCAL NEAR os2open();
  62. PASCAL NEAR os2close();
  63. PASCAL NEAR os2getc();
  64. PASCAL NEAR os2putc();
  65. PASCAL NEAR os2flush();
  66. PASCAL NEAR os2rev();
  67. PASCAL NEAR os2kclose();
  68. PASCAL NEAR os2kopen();
  69. PASCAL NEAR os2cres();
  70. PASCAL NEAR os2parm();
  71. #if    COLOR
  72. PASCAL NEAR os2fcol();
  73. PASCAL NEAR os2bcol();
  74. #endif
  75.  
  76. struct {            /* Current screen attribute for ORing    */
  77.     BYTE    filler;        /* with character to be displayed.    */
  78.     BYTE    attr;
  79. } os2cell = {0, 0x07};
  80.  
  81. struct {            /* Current reverse screen attribute for    */
  82.     BYTE    filler;        /* ORing with character to be displayed.*/
  83.     BYTE    attr;
  84. } os2rcell = {0, 0x07};
  85.  
  86. static struct {                /* initial states        */
  87.     USHORT        ansiState;    /* ANSI translation        */
  88.     VIOCONFIGINFO    vioConfigInfo;    /* video configuration        */
  89.     VIOMODEINFO    vioModeInfo;    /* video mode            */
  90.     KBDINFO        kbdInfo;    /* keyboard info        */
  91. } initial;
  92.  
  93. static int    cfcolor = -1;        /* current foreground color    */
  94. static int    cbcolor = -1;        /* current background color    */
  95. static int    ctrans[] =    /* ansi to ibm color translation table    */
  96.     {0, 4, 2, 6, 1, 5, 3, 7,
  97.      8, 12, 10, 14, 9, 13, 11, 15};
  98.  
  99. static short     os2row;        /* current cursor row    */
  100. static short     os2col;        /* current cursor col    */
  101.  
  102. int revflag = FALSE;            /* are we currently in rev video? */
  103.  
  104. /*
  105.  * To minimize the amount of buffer that VioShowBuf has to update, we
  106.  * keep track of the lowest and highest bytes in the logical video
  107.  * buffer which have been modified.
  108.  */
  109. static USHORT    *lvb;            /* logical video buffer    */
  110. static USHORT     lvbLen;        /* length of buffer    */
  111. static USHORT     lvbMin;        /* min index of modified byte    */
  112. static USHORT     lvbMax;        /* max index of modified byte    */
  113.  
  114. /*
  115.  * Standard terminal interface dispatch table.
  116.  */
  117. TERM    term    = {
  118.     NROW-1,
  119.     NROW-1,
  120.     NCOL,
  121.     NCOL,
  122.     0, 0,
  123.     MARGIN,
  124.     SCRSIZ,
  125.     NPAUSE,
  126.     os2open,
  127.     os2close,
  128.     os2kopen,
  129.     os2kclose,
  130.     os2getc,
  131.     os2putc,
  132.     os2flush,
  133.     os2move,
  134.     os2eeol,
  135.     os2eeop,
  136.     os2eeop,
  137.     os2beep,
  138.     os2rev,
  139.     os2cres
  140. #if    COLOR
  141.     , os2fcol,
  142.     os2bcol
  143. #endif
  144. };
  145.  
  146. #if    MOUSE
  147. /*    Mousing global variable    */
  148. static int mexist;    /* is the mouse driver installed? */
  149. static int nbuttons;    /* number of buttons on the mouse */
  150. static int oldbut;    /* Previous state of mouse buttons */
  151. static int oldcol;    /* previous x position of mouse */
  152. static int oldrow;    /* previous y position of mouse */
  153. HMOU mouse_handle;    /* handle to opened mouse */
  154. #endif
  155.  
  156. /*    input buffers and pointers    */
  157.  
  158. #define    IBUFSIZE    64    /* this must be a power of 2 */
  159.  
  160. unsigned char in_buf[IBUFSIZE];    /* input character buffer */
  161. int in_next = 0;        /* pos to retrieve next input character */
  162. int in_last = 0;        /* pos to place most recent input character */
  163.  
  164. in_init()    /* initialize the input buffer */
  165.  
  166. {
  167.     in_next = in_last = 0;
  168. }
  169.  
  170. in_check()    /* is the input buffer non-empty? */
  171.  
  172. {
  173.     if (in_next == in_last)
  174.         return(FALSE);
  175.     else
  176.         return(TRUE);
  177. }
  178.  
  179. in_put(event)
  180.  
  181. int event;    /* event to enter into the input buffer */
  182.  
  183. {
  184.     in_buf[in_last++] = event;
  185.     in_last &= (IBUFSIZE - 1);
  186. }
  187.  
  188. int in_get()    /* get an event from the input buffer */
  189.  
  190. {
  191.     register int event;    /* event to return */
  192.  
  193.     event = in_buf[in_next++];
  194.     in_next &= (IBUFSIZE - 1);
  195.     return(event);
  196. }
  197.  
  198. #if    COLOR
  199. /*----------------------------------------------------------------------*/
  200. /*    os2fcol()                            */
  201. /* Set the current foreground color.                    */
  202. /*----------------------------------------------------------------------*/
  203.  
  204. PASCAL NEAR os2fcol(
  205.     int color)            /* color to set */
  206. {
  207.     if (dtype != CDMONO)
  208.         cfcolor = ctrans[color];
  209.     else
  210.         cfcolor = 7;
  211.  
  212.     /* set the normal attribute */
  213.     os2cell.attr &= 0xF0;
  214.     os2cell.attr |= cfcolor;
  215.  
  216.     /* set the reverse attribute */
  217.     os2rcell.attr &= 0x07;
  218.     os2rcell.attr |= cfcolor << 4;    
  219. }
  220.  
  221. /*----------------------------------------------------------------------*/
  222. /*    os2bcol()                            */
  223. /* Set the current background color.                    */
  224. /*----------------------------------------------------------------------*/
  225.  
  226. PASCAL NEAR os2bcol(
  227.     int color)        /* color to set */
  228. {
  229.     if (dtype != CDMONO)
  230.         cbcolor = ctrans[color];
  231.     else
  232.         cbcolor = 0;
  233.  
  234.     /* set normal background attribute */
  235.     os2cell.attr &= 0x0F;
  236.     os2cell.attr |= cbcolor << 4;
  237.  
  238.     /* set reverse background attribute */
  239.     os2rcell.attr &= 0x70;
  240.     os2rcell.attr |= cbcolor;
  241. }
  242. #endif
  243.  
  244.  
  245. /*----------------------------------------------------------------------*/
  246. /*    os2move()                            */
  247. /* Move the cursor.                            */
  248. /*----------------------------------------------------------------------*/
  249.  
  250. PASCAL NEAR os2move(
  251.     int row,
  252.     int col)
  253. {
  254.     os2row = row;
  255.     os2col = col;
  256.     VioSetCurPos(os2row, os2col, 0);
  257. }
  258.  
  259.  
  260. /*----------------------------------------------------------------------*/
  261. /*    os2flush()                            */
  262. /* Update the physical video buffer from the logical video buffer.    */
  263. /*----------------------------------------------------------------------*/
  264.  
  265. PASCAL NEAR os2flush(void)
  266. {
  267.     if (lvbMin <= lvbMax) {        /* did anything change?    */
  268.         VioShowBuf(lvbMin * 2, (lvbMax - lvbMin + 1) * 2, 0);
  269.         VioSetCurPos(os2row, os2col, 0);
  270.     }
  271.     lvbMin = lvbLen;
  272.     lvbMax = 0;
  273. }
  274.  
  275.  
  276. /*----------------------------------------------------------------------*/
  277. /*    os2char()                            */
  278. /* Get a character from the keyboard.                    */
  279. /* Function keys, editing keys and alt- keys queue extra bytes into     */
  280. /* input queue.
  281. /*----------------------------------------------------------------------*/
  282.  
  283. PASCAL NEAR os2char()
  284. {
  285.     register c;        /* extended key code for special keys */
  286.     KBDKEYINFO keyInfo;
  287.  
  288.     KbdCharIn(&keyInfo, IO_WAIT, 0);    /* get a character    */
  289.  
  290.     /* Function, edit or alt- key?    */
  291.     if (keyInfo.chChar == 0  ||  keyInfo.chChar == 0xE0) {
  292.         c = extcode(keyInfo.chScan); /* hold on to scan code */
  293.         in_put(c >> 8);        /* queue up prefix byte */
  294.         in_put(c & 0xFF);    /* queue up event byte */
  295.         return(0);
  296.     }
  297.     return(keyInfo.chChar & 255);
  298. }
  299.  
  300. /*
  301.  * Read a character from the terminal, performing no editing and doing no echo
  302.  * at all. Also mouse events are forced into the input stream here.
  303.  */
  304. PASCAL NEAR os2getc()
  305.  
  306. {
  307.     register int c;        /* character read */
  308. #if    MOUSE
  309.     NOPTRRECT mouse_rect;
  310. #endif
  311.  
  312.     os2flush();
  313.  
  314. ttc:    /* return any keystrokes waiting in the
  315.        type ahead buffer */
  316.     if (in_check())
  317.         return(in_get());
  318.  
  319. #if    TYPEAH
  320.     if (typahead())
  321.         return(os2char());
  322.  
  323.     /* with no mouse, this is a simple get char routine */
  324.     if (mexist == FALSE || mouseflag == FALSE)
  325.         return(os2char());
  326.  
  327. #if    MOUSE
  328.     /* turn the mouse cursor on */
  329.     MouDrawPtr(mouse_handle);
  330.  
  331.     /* loop waiting for something to happen */
  332.     while (TRUE) {
  333.         if (typahead())
  334.             break;
  335.         if (checkmouse())
  336.             break;
  337.         DosSleep(10L);    /* let others have some CPU! */
  338.     }
  339.  
  340.     /* turn the mouse cursor back off */
  341.     mouse_rect.row = 0;
  342.     mouse_rect.col = 0;
  343.     mouse_rect.cRow = 24;
  344.     mouse_rect.cCol = 79;
  345.     MouRemovePtr(&mouse_rect, mouse_handle);
  346.  
  347.     goto ttc;
  348. #endif    /* MOUSE */
  349. #else    /* TYPEAH */
  350.     return(os2char());
  351. #endif    /* TYPEAH */
  352. }
  353.  
  354. #if    MOUSE
  355. checkmouse()
  356.  
  357. {
  358.     register int k;        /* current bit/button of mouse */
  359.     register int etype;    /* event type byte */
  360.     register int event;    /* encoded mouse event */
  361.     int mousecol;        /* current mouse column */
  362.     int mouserow;        /* current mouse row */
  363.     int sstate;        /* current shift key status */
  364.     int newbut;        /* new state of the mouse buttons */
  365.     MOUEVENTINFO mouse_event;    /* info about a mouse event */
  366.     MOUQUEINFO mouse_queue;    /* holds info about the mouse queue */
  367.     USHORT wait_flag;    /* wait flag for read mouse queue call */
  368.     KBDINFO kbd_info;    /* keyboard information */
  369.  
  370.     /* is there a mouse event queued up? */
  371.     MouGetNumQueEl(&mouse_queue, mouse_handle);
  372.     if (mouse_queue.cEvents == 0)
  373.         return(FALSE);    
  374.  
  375.     /* get the current mouse event */
  376.     wait_flag = MOU_WAIT;
  377.     MouReadEventQue(&mouse_event, &wait_flag, mouse_handle);
  378.  
  379.     /* build a simple bit field out of OS/2's rather complex one */
  380.     newbut = 0;
  381.     if (mouse_event.fs & MOUSE_BN1_DOWN)
  382.         newbut |= 1;
  383.     if (mouse_event.fs & MOUSE_MOTION_WITH_BN1_DOWN)
  384.         newbut |= 1;
  385.     if (mouse_event.fs & MOUSE_BN2_DOWN)
  386.         newbut |= 2;
  387.     if (mouse_event.fs & MOUSE_MOTION_WITH_BN2_DOWN)
  388.         newbut |= 2;
  389.     if (mouse_event.fs & MOUSE_BN3_DOWN)
  390.         newbut |= 4;
  391.     if (mouse_event.fs & MOUSE_MOTION_WITH_BN3_DOWN)
  392.         newbut |= 4;
  393.  
  394.     /* check to see if any mouse buttons are different */
  395.     mousecol = mouse_event.col;
  396.     mouserow = mouse_event.row;
  397.  
  398.     /* only notice changes */
  399.     if ((oldbut == newbut) && (mousecol == oldcol)
  400.         && (mouserow == oldrow))
  401.         return(FALSE);
  402.  
  403.     /* get the shift key status as well */
  404.     KbdGetStatus(&kbd_info, 0);
  405.     etype = MOUS >> 8;
  406.     sstate = kbd_info.fsState;
  407.     if (sstate & (RIGHTSHIFT | LEFTSHIFT)) /* shifted */
  408.         etype |= (SHFT >> 8);
  409.     else if (sstate & CONTROL)    /* controled? */
  410.         etype |= (CTRL >> 8);
  411.  
  412.     /* no buttons changes */
  413.     if (oldbut == newbut) {
  414.  
  415.         /* generate a mouse movement */
  416.         if (((mouse_move == 1) && (mmove_flag == TRUE)) ||
  417.             (mouse_move == 2)) {
  418.             in_put(0);
  419.             in_put(etype);
  420.             in_put(mousecol);
  421.             in_put(mouserow);
  422.             in_put('m');
  423.         }
  424.         oldcol = mousecol;
  425.         oldrow = mouserow;
  426.         return(TRUE);
  427.     }
  428.  
  429.     /* only on screen presses are legit! */
  430.     if (mousecol < 0)
  431.         mousecol = 0;
  432.     if (mouserow < 0)
  433.         mouserow = 0;
  434.  
  435.     for (k = 1; k != (1 << nbuttons); k = k << 1) {
  436.  
  437.         /* For each button on the mouse */
  438.         if ((oldbut&k) != (newbut&k)) {
  439.             /* This button changed, generate an event */
  440.             in_put(0);
  441.             in_put(etype);
  442.             in_put(mousecol);
  443.             in_put(mouserow);
  444.  
  445.             event = ((newbut&k) ? 0 : 1);    /* up or down? */
  446.             if (k == 2)            /* center button? */
  447.                 event += 4;
  448.             if (k == 4)            /* right button? */
  449.                 event += 2;
  450.             event += 'a';        /* plain */
  451.             in_put(event);
  452.             oldbut = newbut;
  453.             oldcol = mousecol;
  454.             oldrow = mouserow;
  455.             return(TRUE);
  456.         }
  457.     }
  458.     return(TRUE);
  459. }
  460. #endif
  461.  
  462. #if    TYPEAH
  463. /*----------------------------------------------------------------------*/
  464. /*    typahead()                            */
  465. /* Returns true if a key has been pressed.                */
  466. /*----------------------------------------------------------------------*/
  467.  
  468. PASCAL NEAR typahead()
  469.  
  470. {
  471.     KBDKEYINFO kbdinfo;
  472.  
  473.     KbdPeek(&kbdinfo, 0);
  474.     return(kbdinfo.fbStatus != 0);
  475. }
  476. #endif
  477.  
  478.  
  479. /*----------------------------------------------------------------------*/
  480. /*    os2putc()                            */
  481. /* Put a character at the current position in the current colors.    */
  482. /* Note that this does not behave the same as putc() or VioWrtTTy().    */
  483. /* This routine does nothing with returns and linefeeds.  For backspace */
  484. /* it puts a space in the previous column and moves the cursor to the    */
  485. /* previous column.  For all other characters, it will display the    */
  486. /* graphic representation of the character and put the cursor in the    */
  487. /* next column (even if that is off the screen.  In practice this isn't    */
  488. /* a problem.                                */
  489. /*----------------------------------------------------------------------*/
  490.  
  491. PASCAL NEAR os2putc(int c)
  492. {
  493.     USHORT    cell;
  494.     USHORT    i;
  495.  
  496.     if (c == '\n' || c == '\r') {        /* returns and linefeeds */
  497.         return;
  498.     }
  499.     if (c == '\b') {            /* backspace        */
  500.         cell = ' ' | (revflag ? *(USHORT *)&os2rcell : *(USHORT *)&os2cell);
  501.         --os2col;            /* move cursor back    */
  502.         i = os2row * term.t_ncol + os2col;
  503.     }
  504.     else {
  505.         cell = (0x00ff & c) | (revflag ? *(USHORT *)&os2rcell : *(USHORT *)&os2cell);
  506.         i = os2row * term.t_ncol + os2col;
  507.         ++os2col;            /* move cursor forward    */
  508.     }
  509.     lvb[i] = cell;
  510.     if (i < lvbMin)
  511.         lvbMin = i;
  512.     if (i > lvbMax)
  513.         lvbMax = i;
  514. }
  515.  
  516.  
  517. /*----------------------------------------------------------------------*/
  518. /*    os2eeol()                            */
  519. /* Erase to end of line.                        */
  520. /*----------------------------------------------------------------------*/
  521.  
  522. PASCAL NEAR os2eeol()
  523. {
  524.     USHORT    cell = ' ';
  525.     USHORT  i;
  526.  
  527.     cell |= (revflag ? *(USHORT *)&os2rcell : *(USHORT *)&os2cell);
  528.     
  529.     i = os2row * term.t_ncol + os2col;  /* current cursor position    */
  530.     if (i < lvbMin)
  531.         lvbMin = i;
  532.     while (i < os2row * term.t_ncol + term.t_ncol)
  533.         lvb[ i++] = cell;
  534.     if (--i > lvbMax)
  535.         lvbMax = i;
  536. }
  537.  
  538.  
  539. /*----------------------------------------------------------------------*/
  540. /*    os2eeop()                            */
  541. /* Erase to end of page.                        */
  542. /*----------------------------------------------------------------------*/
  543.  
  544. PASCAL NEAR os2eeop()
  545. {
  546.     USHORT    cell = ' ';
  547.     USHORT  i;
  548.  
  549. #if COLOR
  550.     if (dtype != CDMONO)
  551.         cell |= (ctrans[gbcolor] << 4 | ctrans[gfcolor]) << 8;
  552.     else
  553.         cell |= 0x0700;
  554. #else
  555.     cell |= 0x0700;
  556. #endif
  557.  
  558.     i = os2row * term.t_ncol + os2col;  /* current cursor position    */
  559.     if (i < lvbMin)
  560.         lvbMin = i;
  561.     while (i < term.t_nrow * term.t_ncol + term.t_ncol)
  562.         lvb[ i++] = cell;
  563.     if (--i > lvbMax)
  564.         lvbMax = i;
  565. }
  566.  
  567. /*----------------------------------------------------------------------*/
  568. /*    os2rev()                            */
  569. /* Change reverse video state.                      */
  570. /*----------------------------------------------------------------------*/
  571.  
  572. PASCAL NEAR os2rev(state)
  573.  
  574. int state;    /* TRUE = reverse, FALSE = normal */
  575.  
  576. {
  577.     revflag = state;
  578. }
  579.  
  580. /*----------------------------------------------------------------------*/
  581. /*    os2cres()                            */
  582. /* Change the screen resolution.                    */
  583. /*----------------------------------------------------------------------*/
  584.  
  585. PASCAL NEAR os2cres(char *res)        /* name of desired video mode    */
  586. {
  587.     USHORT    err;
  588.     int    type;            /* video mode type    */
  589.     VIOMODEINFO vioModeInfo;
  590.  
  591.     vioModeInfo = initial.vioModeInfo;
  592.     
  593.     /* From the name, find the type of video mode.    */
  594.     for (type = 0; type < NDRIVE; type++) {
  595.         if (strcmp(res, drvname[type]) == 0)
  596.             break;
  597.     }
  598.     if (type == NDRIVE)
  599.         return(FALSE);    /* not a mode we know about    */
  600.  
  601.         
  602.     switch (type) {
  603.         case CDMONO:
  604.         case CDCGA:
  605.             vioModeInfo.row = 25;
  606.             break;
  607.         case CDEGA:
  608.             vioModeInfo.row = 43;
  609.             break;
  610.         case CDVGA:
  611.             vioModeInfo.row = 50;
  612.             break;
  613.     }
  614.     
  615.     if (VioSetMode(&vioModeInfo, 0))    /* change modes     */
  616.         return(FALSE);            /* couldn't do it    */
  617.  
  618.     newsize(TRUE, vioModeInfo.row);
  619.  
  620.     /* reset the $sres environment variable */
  621.     strcpy(sres, drvname[type]);
  622.     dtype = type;                /* set the current mode    */
  623.     
  624.     return TRUE;
  625. }
  626.  
  627.  
  628. /*----------------------------------------------------------------------*/
  629. /*    spal()                                */
  630. /* Change pallette settings.  (Does nothing.)                */
  631. /*----------------------------------------------------------------------*/
  632.  
  633. PASCAL NEAR spal(char *dummy)
  634. {
  635. }
  636.  
  637.  
  638. /*----------------------------------------------------------------------*/
  639. /*    os2beep()                            */
  640. /*----------------------------------------------------------------------*/
  641.  
  642. PASCAL NEAR os2beep()
  643. {
  644.     DosBeep(1200, 175);
  645. }
  646.  
  647.  
  648. /*----------------------------------------------------------------------*/
  649. /*    os2open()                            */
  650. /* Find out what kind of video adapter we have and the current video    */
  651. /* mode.  Even if the adapter supports a higher resolution mode than is */
  652. /* in use, we still use the current mode.                */
  653. /*----------------------------------------------------------------------*/
  654.  
  655. PASCAL NEAR os2open()
  656. {
  657. #if    MOUSE
  658.     PTRLOC mouse_pos;    /* position to place mouse */
  659.     USHORT event_mask;        /* event mask for mouse handling */
  660. #endif
  661.  
  662.     initial.vioConfigInfo.cb = 0x0A;
  663.     VioGetConfig(0, &initial.vioConfigInfo, 0);
  664.     switch (initial.vioConfigInfo.adapter) {
  665.         case DISPLAY_VGA:
  666.             dtype = CDVGA;
  667.             break;
  668.         case DISPLAY_EGA:
  669.             dtype = CDEGA;
  670.             break;
  671.         case DISPLAY_CGA:
  672.         case 8:    /* some new mode in OS/2 2.0 */
  673.             dtype = CDCGA;
  674.             break;
  675.         case DISPLAY_MONOCHROME:
  676.         default:
  677.             dtype = CDMONO;
  678.     }
  679.     strcpy(sres, drvname[dtype]);
  680.  
  681.     initial.vioModeInfo.cb = 0x0E;
  682.     VioGetMode(&initial.vioModeInfo, 0);
  683.     newsize(TRUE, initial.vioModeInfo.row);
  684.             
  685.     VioGetAnsi(&initial.ansiState, 0);
  686.     VioGetBuf((PULONG)&lvb, &lvbLen, 0);
  687.     lvbMin = lvbLen;
  688.     lvbMax = 0;
  689.  
  690.     revexist = TRUE;
  691.     revflag = FALSE;
  692.  
  693.     /* initialize our character input queue */
  694.     in_init();
  695.     strcpy(os, "OS2");
  696.  
  697. #if    MOUSE
  698.     /* find out if we have a mouse */
  699.     if (MouOpen((PSZ)0, &mouse_handle) != 0) {
  700.         mexist = FALSE;
  701.         return;
  702.     }
  703.  
  704.     /* find out some info about the mouse */
  705.     mexist = TRUE;
  706.     MouGetNumButtons(&nbuttons, mouse_handle);
  707.  
  708.     /* tell it what events were interested in */
  709. /*    event_mask = MOUSE_BN1_DOWN | MOUSE_BN2_DOWN | MOUSE_BN3_DOWN;*/
  710.     event_mask = 0xff;
  711.     MouSetEventMask(&event_mask, mouse_handle);
  712.  
  713.     /* get the mouse in the upper right corner */
  714.     oldrow = mouse_pos.row = 0;    /* top row of display */
  715.     oldcol = mouse_pos.col = (term.t_ncol - 1); /* last col of display */
  716.     MouSetPtrPos(&mouse_pos, mouse_handle);
  717. #else
  718.     mexist = FALSE;
  719. #endif
  720. }
  721.  
  722. /*----------------------------------------------------------------------*/
  723. /*    os2close()                            */
  724. /* Restore the original video settings.                    */
  725. /*----------------------------------------------------------------------*/
  726.  
  727. PASCAL NEAR os2close()
  728. {
  729. #if    MOUSE
  730.     /* close our use of the mouse */
  731.     if (mexist)
  732.         MouClose(mouse_handle);
  733. #endif
  734.  
  735.     VioSetAnsi(initial.ansiState, 0);
  736.     VioSetMode(&initial.vioModeInfo, 0);
  737.     VioSetCurPos(initial.vioModeInfo.row - 1,
  738.              initial.vioModeInfo.col - 1, 0);
  739. }
  740.  
  741. /*----------------------------------------------------------------------*/
  742. /*    os2kopen()                            */
  743. /* Open the keyboard.                            */
  744. /*----------------------------------------------------------------------*/
  745.  
  746. PASCAL NEAR os2kopen()
  747. {
  748.     KBDINFO    kbdInfo;
  749.  
  750.     initial.kbdInfo.cb = 0x000A;
  751.     KbdGetStatus(&initial.kbdInfo, 0);    
  752.     kbdInfo = initial.kbdInfo;
  753.     kbdInfo.fsMask &= ~0x0001;        /* not echo on        */
  754.     kbdInfo.fsMask |= 0x0002;        /* echo off        */
  755.     kbdInfo.fsMask &= ~0x0008;        /* cooked mode off    */
  756.     kbdInfo.fsMask |= 0x0004;        /* raw mode        */
  757.     kbdInfo.fsMask &= ~0x0100;        /* shift report    off    */
  758.     KbdSetStatus(&kbdInfo, 0);
  759. }
  760.  
  761.  
  762. /*----------------------------------------------------------------------*/
  763. /*    os2kclose()                            */
  764. /* Close the keyboard.                            */
  765. /*----------------------------------------------------------------------*/
  766.  
  767. PASCAL NEAR os2kclose()
  768. {
  769.     KbdSetStatus(&initial.kbdInfo, 0); /* restore original state    */
  770. }
  771.  
  772. #if    FLABEL
  773. PASCAL NEAR fnclabel(f, n)    /* label a function key */
  774.  
  775. int f,n;    /* default flag, numeric argument [unused] */
  776.  
  777. {
  778.     /* on machines with no function keys...don't bother */
  779.     return(TRUE);
  780. }
  781. #endif
  782.  
  783. #if 0
  784. /*----------------------------------------------------------------------*/
  785. /*    scwrite()                            */
  786. /* Write a line to the screen.
  787. /* I tried using this routine with MEMMAP = 1, but there were too many    */
  788. /* problems with the cursor and flushing the buffer.            */
  789. /*----------------------------------------------------------------------*/
  790.  
  791. scwrite(
  792.     int     row,    /* row of screen to place outstr on */
  793.     char    *outstr,/* string to write out (must be term.t_ncol long) */
  794.     int     forg,    /* foreground color of string to write */
  795.     int     bacg,    /* background color */
  796. {
  797.     USHORT     attr;
  798.     int     i;
  799.  
  800.     attr = (((ctrans[bacg] & 15) << 4) | (forg & 15)) << 8;
  801.  
  802.     for (i = row * term.t_ncol;  i < (row + 1) * term.t_ncol;  i++)
  803.         lvb[i] = attr | *(outstr++);
  804.  
  805.     if (i < lvbMin)
  806.         lvbMin = i;
  807.     if (i > lvbMax)
  808.         lvbMax = i;
  809. }
  810. #endif
  811. #endif
  812.  
  813.